home *** CD-ROM | disk | FTP | other *** search
/ Amiga Plus 2000 #5 / Amiga Plus CD - 2000 - No. 5.iso / Tools / Dev / lame_src / util.c < prev    next >
Encoding:
C/C++ Source or Header  |  2000-01-01  |  16.6 KB  |  639 lines
  1.  
  2. #include "util.h"
  3. #include <assert.h>
  4.  
  5. #ifdef LAME_STD_PRINT
  6. #include <stdarg.h>
  7. #endif
  8.  
  9. /***********************************************************************
  10. *
  11. *  Global Variable Definitions
  12. *
  13. ***********************************************************************/
  14.  
  15.  
  16. /* 1: MPEG-1, 0: MPEG-2 LSF, 1995-07-11 shn */
  17. int     bitrate_table[2][15] = {
  18.           {0,8,16,24,32,40,48,56,64,80,96,112,128,144,160},
  19.           {0,32,40,48,56,64,80,96,112,128,160,192,224,256,320}};
  20.  
  21.  
  22. enum byte_order NativeByteOrder = order_unknown;
  23.  
  24. /***********************************************************************
  25. *
  26. *  Global Function Definitions
  27. *
  28. ***********************************************************************/
  29. FLOAT8 ATHformula(FLOAT8 f)
  30. {
  31.   FLOAT8 ath;
  32.   f  = Max(0.01, f);
  33.   f  = Min(18.0,f);
  34.  
  35.   /* from Painter & Spanias, 1997 */
  36.   /* minimum: (i=77) 3.3kHz = -5db */
  37.   ath =    3.640 * pow(f,-0.8)
  38.          - 6.500 * exp(-0.6*pow(f-3.3,2.0))
  39.          + 0.001 * pow(f,4.0);
  40.   return ath;
  41. }
  42.  
  43.  
  44. FLOAT8 freq2bark(FLOAT8 freq)
  45. {
  46.   /* input: freq in hz  output: barks */
  47.     freq = freq * 0.001;
  48.     return 13.0*atan(.76*freq) + 3.5*atan(freq*freq/(7.5*7.5));
  49. }
  50.  
  51.  
  52.  
  53.  
  54.  
  55.  
  56.  
  57. /***********************************************************************
  58.  * compute bitsperframe and mean_bits for a layer III frame 
  59.  **********************************************************************/
  60. void getframebits(lame_global_flags *gfp,int *bitsPerFrame, int *mean_bits) {
  61.   int whole_SpF;
  62.   lame_internal_flags *gfc=gfp->internal_flags;
  63.  
  64. #if 0  
  65.   FLOAT8 bit_rate,samp;
  66.   
  67.   samp =      gfp->out_samplerate/1000.0;
  68.   if (gfc->bitrate_index) 
  69.     bit_rate = bitrate_table[gfp->version][gfc->bitrate_index];
  70.   else
  71.     bit_rate = gfp->brate;
  72.  
  73.   /* -f fast-math option causes some strange rounding here, be carefull: */  
  74.   whole_SpF = floor( (gfp->framesize /samp)*(bit_rate /  8.0) + 1e-9);
  75. #else
  76.   long bit_rate;
  77.   
  78.   if (gfc->bitrate_index) 
  79.     bit_rate = bitrate_table[gfp->version][gfc->bitrate_index];
  80.   else
  81.     bit_rate = gfp->brate;
  82.   
  83.   whole_SpF=((gfp->version+1)*72000L*bit_rate) / gfp->out_samplerate;
  84. #endif
  85.   *bitsPerFrame = 8 * (whole_SpF + gfc->padding);
  86.   *mean_bits = (*bitsPerFrame - 8*gfc->sideinfo_len) / gfc->mode_gr;
  87.  
  88. }
  89.  
  90.  
  91.  
  92.  
  93. void display_bitrates(FILE *out_fh)
  94. {
  95.   int index,version;
  96.  
  97.   version = 1;
  98.   fprintf(out_fh,"\n");
  99.   fprintf(out_fh,"MPEG1 layer III samplerates(kHz): 32 44.1 48 \n");
  100.  
  101.   fprintf(out_fh,"bitrates(kbs): ");
  102.   for (index=1;index<15;index++) {
  103.     fprintf(out_fh,"%i ",bitrate_table[version][index]);
  104.   }
  105.   fprintf(out_fh,"\n");
  106.   
  107.   
  108.   version = 0;
  109.   fprintf(out_fh,"\n");
  110.   fprintf(out_fh,"MPEG2 layer III samplerates(kHz): 16 22.05 24 \n");
  111.   fprintf(out_fh,"bitrates(kbs): ");
  112.   for (index=1;index<15;index++) {
  113.     fprintf(out_fh,"%i ",bitrate_table[version][index]);
  114.   }
  115.   fprintf(out_fh,"\n");
  116.  
  117.   version = 0;
  118.   fprintf(out_fh,"\n");
  119.   fprintf(out_fh,"MPEG2.5 layer III samplerates(kHz): 8 11.025 12 \n");
  120.   fprintf(out_fh,"bitrates(kbs): ");
  121.   for (index=1;index<15;index++) {
  122.     fprintf(out_fh,"%i ",bitrate_table[version][index]);
  123.   }
  124.   fprintf(out_fh,"\n");
  125. }
  126.  
  127.  
  128. #define ABS(A) (((A)>0) ? (A) : -(A))
  129.  
  130. int FindNearestBitrate(
  131. int bRate,        /* legal rates from 32 to 448 */
  132. int version,      /* MPEG-1 or MPEG-2 LSF */
  133. int samplerate)   /* convert bitrate in kbps to index */
  134. {
  135.   int     index = 0;
  136.   int     bitrate = 10000;
  137.   
  138.   while( index<15)   {
  139.     if( ABS( bitrate_table[version][index] - bRate) < ABS(bitrate-bRate) ) {
  140.       bitrate = bitrate_table[version][index];
  141.     }
  142.     ++index;
  143.   }
  144.   return bitrate;
  145. }
  146.  
  147.  
  148. /* map samplerate to a valid samplerate
  149.  *
  150.  * Robert.Hegemann@gmx.de 2000-07-01
  151.  */
  152. long validSamplerate(long samplerate)
  153. {
  154.     if (samplerate<= 8000) return  8000;
  155.     if (samplerate<=11025) return 11025;
  156.     if (samplerate<=12000) return 12000;
  157.     if (samplerate<=16000) return 16000;
  158.     if (samplerate<=22050) return 22050;
  159.     if (samplerate<=24000) return 24000;
  160.     if (samplerate<=32000) return 32000;
  161.     if (samplerate<=44100) return 44100;
  162.     
  163.     return 48000;
  164. }
  165.  
  166. int BitrateIndex(
  167. int bRate,        /* legal rates from 32 to 448 */
  168. int version,      /* MPEG-1 or MPEG-2 LSF */
  169. int samplerate)   /* convert bitrate in kbps to index */
  170. {
  171. int     index = 0;
  172. int     found = 0;
  173.  
  174.     while(!found && index<15)   {
  175.         if(bitrate_table[version][index] == bRate)
  176.             found = 1;
  177.         else
  178.             ++index;
  179.     }
  180.     if(found)
  181.         return(index);
  182.     else {
  183.         ERRORF("Bitrate %dkbs not legal for %iHz output sampling.\n",
  184.                 bRate, samplerate);
  185.         return(-1);     /* Error! */
  186.     }
  187. }
  188.  
  189. int SmpFrqIndex(  /* convert samp frq in Hz to index */
  190. long sRate,             /* legal rates 16000, 22050, 24000, 32000, 44100, 48000 */
  191. int  *version)
  192. {
  193.     /* Assign default value */
  194.     *version=0;
  195.  
  196.     if (sRate == 44100L) {
  197.         *version = 1; return(0);
  198.     }
  199.     else if (sRate == 48000L) {
  200.         *version = 1; return(1);
  201.     }
  202.     else if (sRate == 32000L) {
  203.         *version = 1; return(2);
  204.     }
  205.     else if (sRate == 24000L) {
  206.         *version = 0; return(1);
  207.     }
  208.     else if (sRate == 22050L) {
  209.         *version = 0; return(0);
  210.     }
  211.     else if (sRate == 16000L) {
  212.         *version = 0; return(2);
  213.     }
  214.     else if (sRate == 12000L) {
  215.         *version = 0; return(1);
  216.     }
  217.     else if (sRate == 11025L) {
  218.         *version = 0; return(0);
  219.     }
  220.     else if (sRate ==  8000L) {
  221.         *version = 0; return(2);
  222.     }
  223.     else {
  224.         ERRORF("SmpFrqIndex: %ldHz is not a legal sample rate\n", sRate);
  225.         return(-1);     /* Error! */
  226.     }
  227. }
  228.  
  229.  
  230.  
  231.  
  232. /*****************************************************************************
  233. *
  234. *  Routines to determine byte order and swap bytes
  235. *
  236. *****************************************************************************/
  237.  
  238. enum byte_order DetermineByteOrder(void)
  239. {
  240.     char s[ sizeof(long) + 1 ];
  241.     union
  242.     {
  243.         long longval;
  244.         char charval[ sizeof(long) ];
  245.     } probe;
  246.     probe.longval = 0x41424344L;  /* ABCD in ASCII */
  247.     strncpy( s, probe.charval, sizeof(long) );
  248.     s[ sizeof(long) ] = '\0';
  249.     /* fprintf( stderr, "byte order is %s\n", s ); */
  250.     if ( strcmp(s, "ABCD") == 0 )
  251.         return order_bigEndian;
  252.     else
  253.         if ( strcmp(s, "DCBA") == 0 )
  254.             return order_littleEndian;
  255.         else
  256.             return order_unknown;
  257. }
  258.  
  259. void SwapBytesInWords( short *loc, int words )
  260. {
  261.     int i;
  262.     short thisval;
  263.     char *dst, *src;
  264.     src = (char *) &thisval;
  265.     for ( i = 0; i < words; i++ )
  266.     {
  267.         thisval = *loc;
  268.         dst = (char *) loc++;
  269.         dst[0] = src[1];
  270.         dst[1] = src[0];
  271.     }
  272. }
  273.  
  274.  
  275.  
  276.  
  277.  
  278.  
  279. /*****************************************************************************
  280. *
  281. *  bit_stream.c package
  282. *  Author:  Jean-Georges Fritsch, C-Cube Microsystems
  283. *
  284. *****************************************************************************/
  285.  
  286. /********************************************************************
  287.   This package provides functions to write (exclusive or read)
  288.   information from (exclusive or to) the bit stream.
  289.  
  290.   If the bit stream is opened in read mode only the get functions are
  291.   available. If the bit stream is opened in write mode only the put
  292.   functions are available.
  293. ********************************************************************/
  294.  
  295. /*alloc_buffer();      open and initialize the buffer;                    */
  296. /*desalloc_buffer();   empty and close the buffer                         */
  297. /*back_track_buffer();     goes back N bits in the buffer                 */
  298. /*unsigned int get1bit();  read 1 bit from the bit stream                 */
  299. /*unsigned long look_ahead(); grep the next N bits in the bit stream without*/
  300. /*                            changing the buffer pointer                   */
  301. /*putbits(); write N bits from the bit stream */
  302. /*int seek_sync(); return 1 if a sync word was found in the bit stream      */
  303. /*                 otherwise returns 0                                      */
  304.  
  305.  
  306.  
  307. void empty_buffer(Bit_stream_struc *bs)
  308. {
  309.   /* brain damaged ISO buffer type - counts down */
  310.   int minimum=1+bs->buf_byte_idx;    /* end of the buffer to empty */
  311.   if (bs->buf_size-minimum <= 0) return;
  312.   bs->buf_byte_idx = bs->buf_size -1;
  313.   bs->buf_bit_idx = 8;
  314.   
  315.   bs->buf[bs->buf_byte_idx] = 0;  /* what does this do? */
  316. }
  317.  
  318.  
  319. int copy_buffer(char *buffer,int size,Bit_stream_struc *bs)
  320. {
  321.   int minimum = bs->buf_byte_idx + 1;
  322.   if (minimum <= 0) return 0;
  323.   if (size!=0 && minimum>size) return -1; /* buffer is too small */
  324.   memcpy(buffer,bs->buf,(unsigned int)minimum);
  325.   bs->buf_byte_idx = -1;
  326.   bs->buf_bit_idx = 0;
  327.   return minimum;
  328. }
  329.  
  330.  
  331.  
  332.  
  333.  
  334. void init_bit_stream_w(lame_internal_flags *gfc)
  335. {
  336.   Bit_stream_struc* bs = &gfc->bs;
  337.    alloc_buffer(bs, BUFFER_SIZE);
  338.    gfc->h_ptr = gfc->w_ptr = 0;
  339.    gfc->header[gfc->h_ptr].write_timing = 0;
  340.    gfc->bs.buf_byte_idx = -1;
  341.    gfc->bs.buf_bit_idx = 0;
  342.    gfc->bs.totbit = 0;
  343. }
  344.  
  345.  
  346. /*open and initialize the buffer; */
  347. void alloc_buffer(
  348. Bit_stream_struc *bs,   /* bit stream structure */
  349. unsigned int size)
  350. {
  351.    bs->buf = (unsigned char *)       malloc(size);
  352.    bs->buf_size = size;
  353. }
  354.  
  355. /*empty and close mallocs in gfc */
  356. void freegfc(lame_internal_flags *gfc)   /* bit stream structure */
  357. {
  358.    free(gfc->bs.buf);
  359.    free(gfc);
  360. }
  361.  
  362. int putmask[9]={0x0, 0x1, 0x3, 0x7, 0xf, 0x1f, 0x3f, 0x7f, 0xff};
  363.  
  364.  
  365.  
  366.  
  367.  
  368. /*****************************************************************************
  369. *
  370. *  End of bit_stream.c package
  371. *
  372. *****************************************************************************/
  373.  
  374. /* reorder the three short blocks By Takehiro TOMINAGA */
  375. /*
  376.   Within each scalefactor band, data is given for successive
  377.   time windows, beginning with window 0 and ending with window 2.
  378.   Within each window, the quantized values are then arranged in
  379.   order of increasing frequency...
  380. */
  381. void ireorder(int scalefac_band[],int ix_orig[576]) {
  382.   int i,sfb, window, j=0;
  383.   int ix[576];
  384.   for (sfb = 0; sfb < SBMAX_s; sfb++) {
  385.     int start = scalefac_band[sfb];
  386.     int end   = scalefac_band[sfb + 1];
  387.     for (window = 0; window < 3; window++) {
  388.       for (i = start; i < end; ++i) {
  389.     ix[j++] = ix_orig[3*i+window];
  390.       }
  391.     }
  392.   }
  393.   memcpy(ix_orig,ix,576*sizeof(int));
  394. }
  395. void iun_reorder(int scalefac_band[],int ix_orig[576]) {
  396.   int i,sfb, window, j=0;
  397.   int ix[576];
  398.   for (sfb = 0; sfb < SBMAX_s; sfb++) {
  399.     int start = scalefac_band[sfb];
  400.     int end   = scalefac_band[sfb + 1];
  401.     for (window = 0; window < 3; window++) {
  402.       for (i = start; i < end; ++i) {
  403.     ix[3*i+window] = ix_orig[j++];
  404.       }
  405.     }
  406.   }
  407.   memcpy(ix_orig,ix,576*sizeof(int));
  408. }
  409. void freorder(int scalefac_band[],FLOAT8 ix_orig[576]) {
  410.   int i,sfb, window, j=0;
  411.   FLOAT8 ix[576];
  412.   for (sfb = 0; sfb < SBMAX_s; sfb++) {
  413.     int start = scalefac_band[sfb];
  414.     int end   = scalefac_band[sfb + 1];
  415.     for (window = 0; window < 3; window++) {
  416.       for (i = start; i < end; ++i) {
  417.     ix[j++] = ix_orig[3*i+window];
  418.       }
  419.     }
  420.   }
  421.   memcpy(ix_orig,ix,576*sizeof(FLOAT8));
  422. }
  423. void fun_reorder(int scalefac_band[],FLOAT8 ix_orig[576]) {
  424.   int i,sfb, window, j=0;
  425.   FLOAT8 ix[576];
  426.   for (sfb = 0; sfb < SBMAX_s; sfb++) {
  427.     int start = scalefac_band[sfb];
  428.     int end   = scalefac_band[sfb + 1];
  429.     for (window = 0; window < 3; window++) {
  430.       for (i = start; i < end; ++i) {
  431.     ix[3*i+window] = ix_orig[j++];
  432.       }
  433.     }
  434.   }
  435.   memcpy(ix_orig,ix,576*sizeof(FLOAT8));
  436. }
  437.  
  438.  
  439.  
  440.  
  441.  
  442.  
  443.  
  444.  
  445.  
  446.  
  447. /* resampling via FIR filter, blackman window */
  448. INLINE double blackman(int i,double offset,double fcn,int l)
  449. {
  450.   double bkwn;
  451.   double wcn = (PI * fcn);
  452.   double dly = l / 2.0;
  453.   double x = i-offset;
  454.   if (x<0) x=0;
  455.   if (x>l) x=l;
  456.   bkwn = 0.42 - 0.5 * cos((x * 2) * PI /l)
  457.     + 0.08 * cos((x * 4) * PI /l);
  458.   if (fabs(x-dly)<1e-9) return wcn/PI;
  459.   else 
  460.     return  (sin( (wcn *  ( x - dly))) / (PI * ( x - dly)) * bkwn );
  461. }
  462.  
  463. int fill_buffer_downsample(lame_global_flags *gfp,short int *outbuf,int desired_len,
  464.              short int *inbuf,int len,int *num_used,int ch) {
  465.   
  466.   lame_internal_flags *gfc=gfp->internal_flags;
  467.   FLOAT8 offset,xvalue;
  468.   int i,j=0,k,value;
  469.   int filter_l;
  470.   FLOAT8 fcn,intratio;
  471.   short int *inbuf_old;
  472.  
  473.   intratio=( fabs(gfc->resample_ratio - floor(.5+gfc->resample_ratio)) < .0001 );
  474.   fcn = .90/gfc->resample_ratio;
  475.   if (fcn>.90) fcn=.90;
  476.   filter_l=19;  /* must be odd */
  477.   /* if resample_ratio = int, filter_l should be even */
  478.   filter_l += intratio;
  479.   assert(filter_l +5 < BLACKSIZE);
  480.   
  481.   if (!gfc->fill_buffer_downsample_init) {
  482.     gfc->fill_buffer_downsample_init=1;
  483.     gfc->itime[0]=0;
  484.     gfc->itime[1]=0;
  485.     memset((char *) gfc->inbuf_old, 0, sizeof(short int)*2*BLACKSIZE);
  486.     /* precompute blackman filter coefficients */
  487.     for (j= 0; j<= 2*BPC; ++j) {
  488.       offset=(double)(j-BPC)/(double)(2*BPC);
  489.       for (i=0; i<=filter_l; ++i) {
  490.     gfc->blackfilt[j][i]=blackman(i,offset,fcn,filter_l);
  491.       }
  492.     }
  493.  
  494.   }
  495.   inbuf_old=gfc->inbuf_old[ch];
  496.  
  497.   /* time of j'th element in inbuf = itime + j/ifreq; */
  498.   /* time of k'th element in outbuf   =  j/ofreq */
  499.   for (k=0;k<desired_len;k++) {
  500.     FLOAT8 time0;
  501.     int joff;
  502.  
  503.     time0 = k*gfc->resample_ratio;       /* time of k'th output sample */
  504.     j = floor( time0 -gfc->itime[ch]  );
  505.     if ((j+filter_l/2) >= len) break;
  506.  
  507.     /* blackmon filter.  by default, window centered at j+.5(filter_l%2) */
  508.     /* but we want a window centered at time0.   */
  509.     offset = ( time0 -gfc->itime[ch] - (j + .5*(filter_l%2)));
  510.     assert(fabs(offset)<=.500001);
  511.     joff = floor((offset*2*BPC) + BPC +.5);
  512.  
  513.     xvalue=0;
  514.     for (i=0 ; i<=filter_l ; ++i) {
  515.       int j2 = i+j-filter_l/2;
  516.       int y;
  517.       y = (j2<0) ? inbuf_old[BLACKSIZE+j2] : inbuf[j2];
  518. #define PRECOMPUTE
  519. #ifdef PRECOMPUTE
  520.       xvalue += y*gfc->blackfilt[joff][i];
  521. #else
  522.       if (intratio) 
  523.     xvalue += y*gfc->blackfilt[joff][i];
  524.       else
  525.     xvalue += y*blackman(i,offset,fcn,filter_l);  /* very slow! */
  526. #endif
  527.     }
  528.     value = floor(.5+xvalue);
  529.     if (value > 32767) outbuf[k]=32767;
  530.     else if (value < -32767) outbuf[k]=-32767;
  531.     else outbuf[k]=value;
  532.   }
  533.  
  534.   
  535.   /* k = number of samples added to outbuf */
  536.   /* last k sample used data from j,j+1, or j+1 overflowed buffer */
  537.   /* remove num_used samples from inbuf: */
  538.   *num_used = Min(len,j+filter_l/2);
  539.   gfc->itime[ch] += *num_used - k*gfc->resample_ratio;
  540.   for (i=0;i<BLACKSIZE;i++)
  541.     inbuf_old[i]=inbuf[*num_used + i -BLACKSIZE];
  542.   return k;
  543. }
  544.  
  545.  
  546. /* 4 point interpolation routine for upsampling */
  547. int fill_buffer_upsample(lame_global_flags *gfp,short int *outbuf,int desired_len,
  548.         short int *inbuf,int len,int *num_used,int ch) {
  549.  
  550.   int i,j=0,k,linear,value;
  551.   lame_internal_flags *gfc=gfp->internal_flags;
  552.   short int *inbuf_old;
  553.  
  554.   if (!gfc->fill_buffer_upsample_init) {
  555.     gfc->fill_buffer_upsample_init=1;
  556.     gfc->upsample_itime[0]=0;
  557.     gfc->upsample_itime[1]=0;
  558.     memset((char *) gfc->upsample_inbuf_old, 0, sizeof(short int)*2*OLDBUFSIZE);
  559.   }
  560.  
  561.  
  562.   inbuf_old=gfc->upsample_inbuf_old[ch];
  563.  
  564.   /* if downsampling by an integer multiple, use linear resampling,
  565.    * otherwise use quadratic */
  566.   linear = ( fabs(gfc->resample_ratio - floor(.5+gfc->resample_ratio)) < .0001 );
  567.  
  568.   /* time of j'th element in inbuf = itime + j/ifreq; */
  569.   /* time of k'th element in outbuf   =  j/ofreq */
  570.   for (k=0;k<desired_len;k++) {
  571.     int y0,y1,y2,y3;
  572.     FLOAT8 x0,x1,x2,x3;
  573.     FLOAT8 time0;
  574.  
  575.     time0 = k*gfc->resample_ratio;       /* time of k'th output sample */
  576.     j = floor( time0 -gfc->upsample_itime[ch]  );
  577.     /* itime[ch] + j;    */            /* time of j'th input sample */
  578.     if (j+2 >= len) break;             /* not enough data in input buffer */
  579.  
  580.     x1 = time0-(gfc->upsample_itime[ch]+j);
  581.     x2 = x1-1;
  582.     y1 = (j<0) ? inbuf_old[OLDBUFSIZE+j] : inbuf[j];
  583.     y2 = ((1+j)<0) ? inbuf_old[OLDBUFSIZE+1+j] : inbuf[1+j];
  584.  
  585.     /* linear resample */
  586.     if (linear) {
  587.       outbuf[k] = floor(.5 +  (y2*x1-y1*x2) );
  588.     } else {
  589.       /* quadratic */
  590.       x0 = x1+1;
  591.       x3 = x1-2;
  592.       y0 = ((j-1)<0) ? inbuf_old[OLDBUFSIZE+(j-1)] : inbuf[j-1];
  593.       y3 = ((j+2)<0) ? inbuf_old[OLDBUFSIZE+(j+2)] : inbuf[j+2];
  594.       value = floor(.5 +
  595.             -y0*x1*x2*x3/6 + y1*x0*x2*x3/2 - y2*x0*x1*x3/2 +y3*x0*x1*x2/6
  596.             );
  597.       if (value > 32767) outbuf[k]=32767;
  598.       else if (value < -32767) outbuf[k]=-32767;
  599.       else outbuf[k]=value;
  600.  
  601.       /*
  602.       printf("k=%i  new=%i   [ %i %i %i %i ]\n",k,outbuf[k],
  603.          y0,y1,y2,y3);
  604.       */
  605.     }
  606.   }
  607.  
  608.  
  609.   /* k = number of samples added to outbuf */
  610.   /* last k sample used data from j,j+1, or j+1 overflowed buffer */
  611.   /* remove num_used samples from inbuf: */
  612.   *num_used = Min(len,j+2);
  613.   gfc->upsample_itime[ch] += *num_used - k*gfc->resample_ratio;
  614.   for (i=0;i<OLDBUFSIZE;i++)
  615.     inbuf_old[i]=inbuf[*num_used + i -OLDBUFSIZE];
  616.   return k;
  617. }
  618.  
  619.  
  620. /***********************************************************************
  621. *
  622. *  Message Output
  623. *
  624. ***********************************************************************/
  625.  
  626. #ifdef LAME_STD_PRINT
  627.  
  628. void
  629. lame_errorf(const char * s, ...)
  630. {
  631.   va_list args;
  632.   va_start(args, s);
  633.   vfprintf(stderr, s, args);
  634.   va_end(args);
  635. }
  636.  
  637. #endif
  638.  
  639.